home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 4 / The Arsenal Files 4 (Arsenal Computer).ISO / casm / au116-as.exe / VERSION.CPP < prev    next >
C/C++ Source or Header  |  1994-12-13  |  15KB  |  675 lines
  1. // VERSION.CPP                                 1          1    6666
  2. // Dave Harris                                11         11   6
  3. // Compiled using Borland C++ ver 3.1       1 1        1 1   6666
  4. // 04-20-94                                  1     ..   1   6   6
  5. //                                           11111 .. 11111  666
  6. ////////////////////////////////////////////////////////////////////////
  7.  
  8. #include "au.hpp"
  9.  
  10. /*********************************************************************/
  11. /* Define Statements */
  12. /*********************/
  13.  
  14. #define PROGRAM "VERSION"    // Name of module
  15.  
  16. /*********************************************************************/
  17.  
  18. #define SZ_SEARCH_STRING 13
  19. #define NUM_ELS 30
  20.  
  21. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  22.  
  23. class VER_WEIGHTS_INFO
  24. {
  25. private:
  26.     struct WEIGHT
  27.     {
  28.         char version[SZ_SEARCH_STRING];
  29.         long weight;
  30.     };
  31.  
  32.     int maxWeights;
  33.     int numWeights;
  34.     WEIGHT *w;
  35.  
  36.     void SharedInit()
  37.     {
  38.         numWeights = 0;
  39.         w = new WEIGHT[maxWeights];
  40.     }
  41.  
  42.     BOOLEAN RemoveSmallest(long);
  43.  
  44. public:
  45.     VER_WEIGHTS_INFO(int x)
  46.     {
  47.         maxWeights = x;
  48.         SharedInit();
  49.     }
  50.  
  51.     VER_WEIGHTS_INFO()
  52.     {
  53.         maxWeights = 20;
  54.         SharedInit();
  55.     }
  56.  
  57.     ~VER_WEIGHTS_INFO()
  58.     {
  59.         delete w;
  60.     }
  61.  
  62.     void add(char *, long);
  63.     void find_largest(char *);
  64.     void display(AU *);
  65. };
  66.  
  67. class WEIGHT_FILE
  68. {
  69.     public:
  70.         int  pos;
  71.         char file_name[NUM_ELS][SZ_SEARCH_STRING];
  72.         int  weight[NUM_ELS];
  73.  
  74.         WEIGHT_FILE()
  75.         {
  76.             pos = 0;
  77.         }
  78.         void add(char *str, int w)
  79.         {
  80.             if (pos < NUM_ELS)
  81.             {
  82.                 safe_string_copy(file_name[pos], str, SZ_SEARCH_STRING, TRUE);
  83.                 weight[pos] = w;
  84.                 pos++;
  85.             }
  86.         }
  87. };
  88.  
  89. class WEIGHT_STRING
  90. {
  91.     public:
  92.         int  pos;
  93.         char string[NUM_ELS][SZ_SEARCH_STRING];
  94.         int  weight[NUM_ELS];
  95.         int  len[NUM_ELS];
  96.  
  97.         WEIGHT_STRING()
  98.         {
  99.             pos = 0;
  100.         }
  101.         void add(char *str, int w)
  102.         {
  103.             if (pos < NUM_ELS)
  104.             {
  105.                 safe_string_copy(string[pos], str, SZ_SEARCH_STRING, TRUE);
  106.                 len[pos] = strlen(str);
  107.                 weight[pos] = w;
  108.                 pos++;
  109.             }
  110.         }
  111. };
  112.  
  113. typedef struct
  114. {
  115.     WEIGHT_FILE weight_file;
  116.     WEIGHT_STRING weight_string;
  117.     char used_as_first[26];
  118.     char show_all;
  119.     int  number;
  120. } VERSION_INFO;
  121.  
  122.  
  123. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  124. BOOLEAN VER_WEIGHTS_INFO::RemoveSmallest(long weight)
  125. {
  126.     long smallest = 999999999;
  127.     int  smallestPos = 0;
  128.  
  129.     /* -3 give the last 3 a chance to mature before being wiped */
  130.  
  131.     for (int i=0; i < numWeights-3; i++)
  132.     {
  133.         if (w[i].weight < smallest)
  134.         {
  135.             smallestPos = i;
  136.             smallest = w[i].weight;
  137.         }
  138.     }
  139.     if (smallest > weight)
  140.         return FALSE;
  141.  
  142.     /* Slide them */
  143.     memmove(&w[smallestPos], &w[smallestPos+1],
  144.             sizeof(WEIGHT) * (numWeights - smallestPos - 1));
  145.     numWeights--;
  146.     return TRUE;
  147. }
  148. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  149. void VER_WEIGHTS_INFO::find_largest(char *buffer)
  150. {
  151.     long largest = 0;
  152.     int  largestPos = 0;
  153.  
  154.     if (numWeights == 0)
  155.     {
  156.         buffer[0] = '\0';
  157.         return;
  158.     }
  159.  
  160.     for (int i=0; i < numWeights; i++)
  161.     {
  162.         if (w[i].weight > largest)
  163.         {
  164.             largestPos = i;
  165.             largest = w[i].weight;
  166.         }
  167.     }
  168.     strcpy(buffer, w[largestPos].version);
  169.     return;
  170. }
  171. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  172. void VER_WEIGHTS_INFO::display(AU *au)
  173. {
  174.     au_printf(au, "\n");
  175.  
  176.     for (int i=0; i < numWeights; i++)
  177.     {
  178.         au_printf(au, "%*s %8ld   ", SZ_SEARCH_STRING, w[i].version,
  179.                   w[i].weight);
  180.         if (i % 3 == 2)
  181.             au_printf(au, "\n");
  182.     }
  183.     au_printf(au, "\n");
  184.     return;
  185. }
  186. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  187. void VER_WEIGHTS_INFO::add(char *ver, long weight)
  188. {
  189.     if (weight == 0)
  190.         return;
  191.  
  192.     for (int i=0; i < numWeights; i++)
  193.     {
  194.         if (stricmp(ver, w[i].version) == 0)
  195.         {
  196.             w[i].weight += weight;
  197.             return;
  198.         }
  199.     }
  200.     if (i == maxWeights)
  201.     {
  202.         if (RemoveSmallest(weight))
  203.         {
  204.             i--;
  205.             w[i].weight = 0;
  206.         }
  207.         else
  208.             return;
  209.     }
  210.     else
  211.     {
  212.         w[numWeights].weight = 0;
  213.     }
  214.     numWeights++;
  215.     strcpy(w[i].version, ver);
  216.     w[i].weight += weight;
  217.  
  218.     return;
  219. }
  220.  
  221. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  222. static int get_file_weight(AU *au, char *file_name)
  223. {
  224.     VERSION_INFO *in = (VERSION_INFO *)au->info;
  225.     int i;
  226.  
  227.     for (i=0; i < in->weight_file.pos; i++)
  228.     {
  229.         if (wildcard_compare(au, file_name, in->weight_file.file_name[i]))
  230.             return in->weight_file.weight[i];
  231.     }
  232.     return 100;
  233. }
  234. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  235. static int find_match(AU *au, char *buffer, long *pos)
  236. {
  237.     VERSION_INFO *in = (VERSION_INFO *)au->info;
  238.     int i;
  239.  
  240.     /* Case sensitive search */
  241.  
  242.     for (i = 0; i < in->weight_string.pos; i++)
  243.     {
  244.         if (strncmp(in->weight_string.string[i], buffer,
  245.                     in->weight_string.len[i]) == 0)
  246.         {
  247.             *pos += in->weight_string.len[i];
  248.             return in->weight_string.weight[i];
  249.         }
  250.     }
  251.  
  252.     /* Case insensitive search, weight is half the amount */
  253.  
  254.     for (i = 0; i < in->weight_string.pos; i++)
  255.     {
  256.         if (strnicmp(in->weight_string.string[i], buffer,
  257.                      in->weight_string.len[i]) == 0)
  258.         {
  259.             *pos += in->weight_string.len[i];
  260.             return in->weight_string.weight[i] / 2;
  261.         }
  262.     }
  263.     return -1;
  264. }
  265. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  266. static int IsAlpha(int c)
  267. {
  268.     return (c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z');
  269. }
  270. static int IsDigit(int c)
  271. {
  272.     return (c >= '0' && c <= '9');
  273. }
  274. static int IsSpace(int c)
  275. {
  276.     return (c >=0x09 && c <= 0x0d || c == 0x20 || c == 0x00);
  277. }
  278. static int IsPunct(int c)
  279. {
  280.     return (strchr(".,:;", c) != NULL);
  281. }
  282. static int is_alpha_ver_char(int c)
  283. {
  284.     return (IsAlpha(c) || c == 0xE0 || c == 0xE1);
  285. }
  286.  
  287. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  288. /* Modifiers
  289.  - Base value 100.
  290.  - If no decimal, then value = size of version string, if over 4 then value =1
  291.  - if version string starts with a decimal /4
  292.  - if version string contains more than one alpha characters then / (x*x)
  293.    where x = number of alpha character found.
  294. -  if version string contains more than one decimal point, then / x
  295.    where x = number of decimal points
  296. -  if version string length > 7 then / (length - 5)
  297. -  for each alpha.alpha appears then /2
  298. -  for each .alpha appears then /2 (so alpha.alpha is really worth a /4)
  299. -  for each alpha digit alpha appears then /3
  300. */
  301.  
  302. static BOOLEAN get_version_string(char *version_string, char *buffer, int len,
  303.                                   int *value, long *pos)
  304. {
  305.     int i=0;
  306.     int ch;
  307.     int vp = 0;
  308.     int is_digit;
  309.     int no_alpha = 0;
  310.     int no_dec = 0;
  311.     int alpha_dot_alpha = 0;
  312.     int dot_alpha = 0;
  313.     int digit_found = 0;
  314.     int alpha_digit_alpha = 0;
  315.  
  316.     while (IsSpace(buffer[i]) && i < len)
  317.         i++;
  318.  
  319.     if (i < len)
  320.     {
  321.         ch = buffer[i];
  322.         is_digit = IsDigit(ch);
  323.         if (is_digit || ch == '.')
  324.         {
  325.             for (;;)
  326.             {
  327.                 ch = buffer[i];
  328.                 is_digit = IsDigit(ch);
  329.  
  330.                 while ((is_digit || ch == '.') && i < len)
  331.                 {
  332.                     if (is_digit)
  333.                         digit_found = TRUE;
  334.                     else
  335.                         no_dec++;
  336.                     version_string[vp++] = ch;
  337.                     i++;
  338.                     if (ch == '.' && buffer[i] == '.')
  339.                         break;
  340.                     ch = buffer[i];
  341.                     is_digit = IsDigit(ch);
  342.                 }
  343.                 if (i < len)
  344.                 {
  345.                     if (is_alpha_ver_char(ch) &&
  346.                         !is_alpha_ver_char(buffer[i+1]))
  347.                     {
  348.                         no_alpha++;
  349.                         if (version_string[vp-1] == '.')
  350.                         {
  351.                             dot_alpha++;
  352.                             if (vp > 1 &&
  353.                                 is_alpha_ver_char(version_string[vp-2]))
  354.                             {
  355.                                 alpha_dot_alpha++;
  356.                             }
  357.                         }
  358.                         else if (vp > 1 &&
  359.                                  IsDigit(version_string[vp-1]) &&
  360.                                  is_alpha_ver_char(version_string[vp-2]))
  361.                         {
  362.                             alpha_digit_alpha++;
  363.                         }
  364.                         version_string[vp++] = ch;
  365.                         i++;
  366.                         continue;
  367.                     }
  368.                 }
  369.                 break;
  370.             }
  371.             if (!digit_found)
  372.                 return FALSE;
  373.             if (version_string[vp-1] == '.')
  374.             {
  375.                 vp--;
  376.                 i--;
  377.                 no_dec--;
  378.                 if (vp == 0)
  379.                     return FALSE;
  380.             }
  381.             version_string[vp] = '\0';
  382.             /* Ignore version 0 */
  383.             if (strcmp(version_string, "0") == 0 ||
  384.                 strcmp(version_string, ".0") == 0 ||
  385.                 strcmp(version_string, ".00") == 0 ||
  386.                 strncmp(version_string, ".0.", 3) == 0)
  387.             {
  388.                 return FALSE;
  389.             }
  390.             else if (no_dec == 0)
  391.             {
  392.                 /* Avoid things like 9A */
  393.  
  394.                 ch = version_string[vp-1];
  395.                 if (!IsDigit(ch) && !IsPunct(ch))
  396.                     return FALSE;
  397.                 if (vp < 4)
  398.                     *value = vp;
  399.                 else
  400.                     *value = 1;
  401.             }
  402.             else
  403.             {
  404.                 *value = 100;
  405.  
  406.                 /* First character is a . */
  407.                 if (version_string[0] == '.')
  408.                     *value /= 4;
  409.  
  410.                 if (no_alpha > 0)
  411.                     *value /= (no_alpha * no_alpha);
  412.  
  413.                 if (no_dec > 0)
  414.                     *value /= no_dec;
  415.  
  416.                 if (vp > 7)
  417.                     *value /= (vp - 5);
  418.  
  419.                 if (alpha_dot_alpha > 0)
  420.                     *value /= (2 * alpha_dot_alpha);
  421.                 if (dot_alpha > 0)
  422.                     *value /= (2 * dot_alpha);
  423.                 if (alpha_digit_alpha > 0)
  424.                     *value /= (3 * alpha_digit_alpha);
  425.             }
  426.             *pos += i;
  427.             return TRUE;
  428.         }
  429.     }
  430.     return FALSE;
  431. }
  432. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  433. static STATUS process_file(AU *au, char *file_name, int weight,
  434.                            VER_WEIGHTS_INFO *weights_info)
  435. {
  436.     VERSION_INFO *in = (VERSION_INFO *)au->info;
  437.     HANDLE handle(16384);
  438.     char   version_string[SZ_SEARCH_STRING+1];
  439.     char   buffer[SZ_SEARCH_STRING+1];
  440.     int    prev_ch;
  441.     long   pos;
  442.     int    len;
  443.     int    val;
  444.     int    i;
  445.     int    ch = ' ';
  446.  
  447.     if (handle.open(au, file_name, O_RDONLY | O_BINARY) != SUCCESS)
  448.         return FAILURE;
  449.  
  450.     pos = 0;
  451.     for (EVER)
  452.     {
  453.         handle.seek(pos, SEEK_SET);
  454.         prev_ch = ch;
  455.         ch = handle.read_char();
  456.         if (ch == EOF)
  457.             break;
  458.         if (!IsDigit(ch) && ch != '.' &&
  459.             strchr(in->used_as_first, toupper(ch)) == NULL)
  460.         {
  461.             pos++;
  462.             continue;
  463.         }
  464.         buffer[0] = ch;
  465.         len = handle.read(buffer+1, sizeof(buffer)-2);
  466.         buffer[len] = '\0';
  467.         if ((i = find_match(au, buffer, &pos)) != -1)
  468.         {
  469.             if (!IsSpace(prev_ch) && !IsPunct(prev_ch))
  470.                 i /= 10;
  471.             handle.seek(pos, SEEK_SET);
  472.             if (handle.read(buffer, sizeof(buffer)-2) == 0)
  473.                 break;
  474.             if (get_version_string(version_string, buffer, len, &val, &pos))
  475.                 weights_info->add(version_string, (long)weight * i);
  476.         }
  477.         else if (get_version_string(version_string, buffer, len, &val, &pos))
  478.         {
  479.             /* Weight it less if character immediately before the number
  480.                is not whitespace of punctuation */
  481.  
  482.             if (IsSpace(prev_ch))
  483.                 val = (val * 3) / 2;
  484.             else if (IsPunct(prev_ch))
  485.                 val /= 2;
  486.             else
  487.                 val /= 3;
  488.  
  489.             if ((long)weight * (long)val > 0 && strlen(version_string) > 1)
  490.                 weights_info->add(version_string, (long)weight * (long)val);
  491.         }
  492.         else
  493.             pos++;
  494.     }
  495.  
  496.     handle.close();
  497.     return SUCCESS;
  498. }
  499. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  500. static int version_one_file(AU *au, char *file_name, char *ver_string)
  501. {
  502.     int weight;
  503.     VERSION_INFO *in = (VERSION_INFO *)au->info;
  504.     VER_WEIGHTS_INFO vwInfo(in->number);
  505.  
  506.     weight = get_file_weight(au, file_name);
  507.     process_file(au, file_name, weight, &vwInfo);
  508.     if (in->show_all == ON)
  509.         vwInfo.display(au);
  510.     vwInfo.find_largest(ver_string);
  511.     return 0;
  512. }
  513. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  514. static int version_archive(AU *au, ARC_HANDLE *, char *file_name, char *ver_string)
  515. {
  516.     struct ffblk ffblk;           // directory entry structure
  517.     char     holdCurDir[FLENGTH];
  518.     char     curDir[FLENGTH];
  519.     char     destDir[FLENGTH];
  520.     LISTPTR  paths;
  521.     int      weight;
  522.     VERSION_INFO *in = (VERSION_INFO *)au->info;
  523.     VER_WEIGHTS_INFO vwInfo(in->number);
  524.  
  525.     getcwd(curDir, FLENGTH);
  526.     build_fname(destDir, curDir, TEMP_DIR);
  527.     mkdir(TEMP_DIR);
  528.  
  529.     unarc(au, file_name, destDir, &paths, 0, FALSE);
  530.     au_printf(au, "\n");
  531.     paths.add(destDir);
  532.  
  533.     for (LIST *el = paths.head; el != NULL; el = el->next)
  534.     {
  535.         cd(au, el->data, NULL);
  536.  
  537.         if (!findfirst("*.*", &ffblk, 0))
  538.         {
  539.             do
  540.             {
  541.                 weight = get_file_weight(au, ffblk.ff_name);
  542.                 process_file(au, ffblk.ff_name, weight, &vwInfo);
  543.             }  while (!findnext(&ffblk));
  544.         }
  545.  
  546.     }
  547.     if (in->show_all == ON)
  548.         vwInfo.display(au);
  549.     vwInfo.find_largest(ver_string);
  550.  
  551.     clean_paths(au, &paths);
  552.     cd(au, curDir, NULL);
  553.     rmdir(TEMP_DIR);
  554.     cd(au, holdCurDir, NULL);
  555.  
  556.     return 0;
  557. }
  558. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  559. static int version(AU *au, char *file_name)
  560. {
  561.     ARC_HANDLE arc_handle;
  562.     char ver_string[30];
  563.  
  564.     check_for_key();
  565.  
  566.     au->number_processed++;
  567.  
  568.     arc_handle.init(au, file_name);
  569.     arc_handle.deinit(au);
  570.     if (arc_handle.type == 0)
  571.         version_one_file(au, file_name, ver_string);
  572.     else
  573.         version_archive(au, &arc_handle, file_name, ver_string);
  574.  
  575.     au_printf(au, "@?1%*s@?H %s\n", FILE_SIZE, file_name, ver_string);
  576.  
  577.     return 0;
  578. }
  579. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  580. static void ReadCFGInfo(AU *au, CFG_HANDLE *cfg_handle)
  581. {
  582.     char string[200],
  583.          string2[200],
  584.          string3[200];
  585.     VERSION_INFO *in = (VERSION_INFO *)au->info;
  586.  
  587.     for(EVER)
  588.     {
  589.         if (cfg_handle->read_line(au, string) == EOF)
  590.             break;
  591.  
  592.         split_string(string, string2);
  593.         split_string(string, string3);
  594.  
  595.         if (string2[0] == '\0')
  596.             continue;
  597.  
  598.         strcpy(au->curOpt, string2);
  599.         au->curVal = string3;
  600.         switch (toupper(string2[1]) << 8 | toupper(string2[0]))
  601.         {
  602.             case 'BE':                                          // Begin
  603.                 return;
  604.             case 'WE':
  605.                 if (stricmp(string2, "WEIGHT_FILE") == 0)
  606.                     in->weight_file.add(string3, atoi(string));
  607.                 else
  608.                 {
  609.                     in->weight_string.add(string3, atoi(string));
  610.                     if (strchr(in->used_as_first, toupper(string3[0])) == NULL)
  611.                     {
  612.                         int len;
  613.                         len = strlen(in->used_as_first);
  614.                         in->used_as_first[len] = toupper(string3[0]);
  615.                         in->used_as_first[len+1] = '\0';
  616.                     }
  617.                 }
  618.                 break;
  619.             default:
  620.                 cfg_handle->invalid_option(au, string2);
  621.         }
  622.     }
  623. }
  624. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  625. static BYTE parse_comm_line(AU *au, char option, char *cur_argv, PARSE_TYPE type)
  626. {
  627.     VERSION_INFO *in = (VERSION_INFO *)au->info;
  628.  
  629.     switch (type)
  630.     {
  631.     case PARSE_PARAM_OPTION:
  632.         switch (option)
  633.         {
  634.             case 'D':
  635.                 in->show_all = get_value(au, OFF | ON);
  636.                 break;
  637.             case 'N':
  638.                 in->number = atoi(cur_argv);
  639.                 break;
  640.             case '?':
  641.                 au_standard_opt_header(au, "Version",
  642.                    "@?3-D@?Hon|off     Display full breakdown\n"
  643.                    "@?3-N@?Hx          Gather top x version strings\n");
  644.                 exit (0);
  645.             default:
  646.                 au_invalid_option(au, PROGRAM, option);
  647.         }
  648.         return TRUE;
  649.     }
  650.     return FALSE;
  651. }
  652. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  653. int main_version(AU *au, int argc, char *argv[])
  654. {
  655.     VERSION_INFO *in;
  656.  
  657.     in = new VERSION_INFO;
  658.     memset(in, '\0', sizeof(VERSION_INFO));
  659.     in->number = 20;
  660.     au->info = in;
  661.  
  662.     ReadGlobalCFGInfo(au, au->cfg_file, PROGRAM, ReadCFGInfo);
  663.     generic_parse_comm_line(au, argc, argv, parse_comm_line);
  664.  
  665.     au->unarc_paths = ON;
  666.     au->recurse = OFF;         // uses a different style of recurse
  667.  
  668.     process_files(au, version);
  669.  
  670.     if (!au->no_extra)
  671.         au_printf_c(au, 15, "\n\nFiles Processed = %d\n", au->number_processed);
  672.  
  673.     return 0;
  674. }
  675.